const Service = require('egg').Service;
const { Op } = require('sequelize');
class PostService extends Service {
    // 创建帖子
    async create(postData) {
        const { ctx } = this;

        // 验证用户是否存在
        const user = await ctx.model.User.findByPk(postData.user_id);
        if (!user) {
            throw new Error('用户不存在');
        }
        // 处理图片字段（如果是数组，转换为逗号分隔的字符串）
        if (postData.images && Array.isArray(postData.images)) {
            postData.images = postData.images.join(',');
        }
        // 创建帖子
        const post = await ctx.model.Post.create({
            ...postData,
            created_at: new Date(),
            updated_at: new Date(),
        });

        return post;
    }

    // 获取帖子列表（分页）
    async getPosts(query) {
        const { ctx } = this;
        const { page = 1, pageSize = 10, user_id, search_keyword, search_type } = query;

        const where = {};
        if (user_id) where.user_id = user_id;

        // 构建关联查询条件
        const includeOptions = {
            model: ctx.model.User,
            as: 'author',
            attributes: ['user_id', 'nickname', 'avatar', 'phone', 'email']
        };

        // 添加搜索功能
        if (search_keyword && search_type) {
            if (search_type === 'post') {
                // 搜索帖子内容
                where.content = {
                    [Op.like]: `%${search_keyword}%` // 使用 Op.like
                };
            } else if (search_type === 'user') {
                // 搜索用户昵称 - 在关联表上添加条件
                includeOptions.where = {
                    nickname: {
                        [Op.like]: `%${search_keyword}%` // 使用 Op.like
                    }
                };
            }
        }

        const options = {
            where,
            limit: parseInt(pageSize),
            offset: (parseInt(page) - 1) * parseInt(pageSize),
            include: [includeOptions],
            order: [['created_at', 'DESC']]
        };

        const { count, rows } = await ctx.model.Post.findAndCountAll(options);

        return {
            list: rows,
            pagination: {
                page: parseInt(page),
                pageSize: parseInt(pageSize),
                total: count,
                totalPages: Math.ceil(count / pageSize)
            }
        };
    }


    // 根据ID获取帖子详情
    async getPostById(postId) {
        const { ctx } = this;

        const post = await ctx.model.Post.findByPk(postId, {
            include: [{
                model: ctx.model.User,
                as: 'author',
                attributes: ['user_id', 'nickname', 'avatar', 'phone', 'email'] // 关联用户信息
            }]
        });

        if (!post) {
            throw new Error('帖子不存在');
        }

        return post;
    }

    // 更新帖子信息
    async updatePost(postId, updateData) {
        const { ctx } = this;

        // 检查帖子是否存在
        const post = await ctx.model.Post.findByPk(postId);
        if (!post) {
            throw new Error('帖子不存在');
        }
        // 处理图片字段（如果是数组，转换为逗号分隔的字符串）
        if (updateData.images && Array.isArray(updateData.images)) {
            updateData.images = updateData.images.join(',');
        }
        // 更新帖子信息
        await post.update({
            ...updateData,
            updated_at: new Date()
        });

        return post;
    }

    // 删除帖子
    async deletePost(postId) {
        const { ctx } = this;

        const post = await ctx.model.Post.findByPk(postId);
        if (!post) {
            throw new Error('帖子不存在');
        }

        await post.destroy();
        return true;
    }

    // 点赞帖子
    async likePost(postId) {
        const { ctx } = this;

        const post = await ctx.model.Post.findByPk(postId);
        if (!post) {
            throw new Error('帖子不存在');
        }

        // 增加点赞数
        await post.increment('like_count');

        return await post.reload(); // 重新加载获取更新后的数据
    }

    // 取消点赞帖子
    async unlikePost(postId) {
        const { ctx } = this;

        const post = await ctx.model.Post.findByPk(postId);
        if (!post) {
            throw new Error('帖子不存在');
        }

        // 减少点赞数，确保不小于0
        if (post.like_count > 0) {
            await post.decrement('like_count');
        }

        return await post.reload();
    }

    // 获取用户的所有帖子
    async getUserPosts(userId, query) {
        const { ctx } = this;
        const { page = 1, pageSize = 10 } = query;

        // 验证用户是否存在
        const user = await ctx.model.User.findByPk(userId);
        if (!user) {
            throw new Error('用户不存在');
        }

        const options = {
            where: { user_id: userId },
            limit: parseInt(pageSize),
            offset: (parseInt(page) - 1) * parseInt(pageSize),
            include: [{
                model: ctx.model.User,
                as: 'author',
                attributes: ['user_id', 'nickname', 'avatar', 'phone', 'email']
            }],
            order: [['created_at', 'DESC']]
        };

        const { count, rows } = await ctx.model.Post.findAndCountAll(options);

        return {
            list: rows,
            pagination: {
                page: parseInt(page),
                pageSize: parseInt(pageSize),
                total: count,
                totalPages: Math.ceil(count / pageSize)
            }
        };
    }

    // 更新评论数量
    async updateCommentCount(postId, change) {
        const { ctx } = this;

        const post = await ctx.model.Post.findByPk(postId);
        if (!post) {
            throw new Error('帖子不存在');
        }

        if (change > 0) {
            await post.increment('comment_count');
        } else if (change < 0 && post.comment_count > 0) {
            await post.decrement('comment_count');
        }

        return await post.reload();
    }
}

module.exports = PostService;